home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 February / EnigmA AMIGA RUN 15 (1997)(G.R. Edizioni)(IT)[!][issue 1997-02][PLANET CD V].iso / enigma / earcd / sviluppo / svilupp2 / muiclstr.lha / txt / MCCListtree.def next >
Text File  |  1995-12-19  |  18KB  |  453 lines
  1. |##########|
  2. |#MAGIC   #|DNEIEICJ
  3. |#PROJECT #|"Mui"
  4. |#PATHS   #|"StdProject"
  5. |#FLAGS   #|xx---x--xxx---x-----------------
  6. |#USERSW  #|--------------------------------
  7. |#USERMASK#|--------------------------------
  8. |#SWITCHES#|xx----xxxx-xx---
  9. |##########|
  10. DEFINITION MODULE MCCListtree;
  11.  
  12. (*------------------------------------------
  13.  
  14.   :Module.      MCCListtree.mod
  15.   :Author.      Henning Thielemann
  16.   :Address.     Veilchenweg 34, 06118 Halle, Germany
  17.   :EMail.       henning.thielemann@student.uni-halle.de
  18.   :Version.     $VER: MCCListtree.mod 12.0 (30.04.96)
  19.   :Copyright.   Henning Thielemann
  20.   :Language.    Cluster
  21.   :Translator.  Amiga Cluster V2.0
  22.   :Contents.    Interface for Klaus Melchior's Mui Custom Class Listtree
  23.   :Bugs.        No warranty given for completeness, expect changes!
  24.   :Usage.       <Angaben zur Anwendung>
  25.   :History.     3.1    [ht]  30-Apr-1996 : initial version
  26.  
  27. --------------------------------------------*)
  28.  
  29. FROM SYSTEM   IMPORT SysStringPtr;
  30. FROM Utility  IMPORT HookPtr;
  31. FROM MuiO     IMPORT ListRec, MethodID, MsgRoot, MuiTagAPtr, MuiTags,
  32.                      CBOOLEAN;
  33.  
  34. (*
  35. **              $VER: MCCListtree.def (30.04.96)
  36. **
  37. **              Listtree.mcc (c) by kMel, Klaus Melchior
  38. **
  39. **              Registered class of the Magic User Interface.
  40. **
  41. **              Cluster interface by Henning Thielemann <thielemann@biochemtech.uni-halle.de>
  42. **              mostly untested, report bugs to the above address.
  43. **
  44. *)
  45.  
  46. TYPE
  47.   ListtreeRec    = RECORD OF ListRec END;
  48.   ListtreeObject = POINTER TO ListtreeRec;
  49.  
  50.   TreeNodeFlags   = (open,  list,  freeze, nosign, ltnf4,  ltnf5,  ltnf6,  ltnf7,
  51.                      ltnf8, ltnf9, ltnf10, ltnf11, ltnf12, ltnf13, ltnf14, ltnf15);
  52.   TreeNodeFlagSet = SET OF TreeNodeFlags;
  53.  
  54.   TreeNodePtr = POINTER TO TreeNode;
  55.   TreeNode    = RECORD
  56.                   private      : ARRAY [2] OF LONGINT;
  57.                   name         : SysStringPtr;
  58.                   flags        : TreeNodeFlagSet;
  59.                   user         : ANYPTR;
  60.                 END; (* RECORD *)
  61.  
  62. CONST
  63.   cListtree = "Listtree.mcc";
  64.  
  65.   closeListNodeRoot          =    TreeNodePtr( 0);
  66.   closeListNodeParent        =    TreeNodePtr(-1);
  67.   closeListNodeActive        =    TreeNodePtr(-2);
  68.  
  69.   closeTreeNodeHead          =    TreeNodePtr( 0);
  70.   closeTreeNodeTail          =    TreeNodePtr(-1);
  71.   closeTreeNodeActive        =    TreeNodePtr(-2);
  72.   closeTreeNodeAll           =    TreeNodePtr(-3);
  73.  
  74.   exchangeListNode1Root      =    TreeNodePtr( 0);
  75.   exchangeListNode1Active    =    TreeNodePtr(-2);
  76.  
  77.   exchangeTreeNode1Head      =    TreeNodePtr( 0);
  78.   exchangeTreeNode1Tail      =    TreeNodePtr(-1);
  79.   exchangeTreeNode1Active    =    TreeNodePtr(-2);
  80.  
  81.   exchangeListNode2Root      =    TreeNodePtr( 0);
  82.   exchangeListNode2Active    =    TreeNodePtr(-2);
  83.  
  84.   exchangeTreeNode2Head      =    TreeNodePtr( 0);
  85.   exchangeTreeNode2Tail      =    TreeNodePtr(-1);
  86.   exchangeTreeNode2Active    =    TreeNodePtr(-2);
  87.   exchangeTreeNode2Up        =    TreeNodePtr(-5);
  88.   exchangeTreeNode2Down      =    TreeNodePtr(-6);
  89.  
  90.   findNameListNodeRoot       =    TreeNodePtr( 0);
  91.   findNameListNodeActive     =    TreeNodePtr(-2);
  92.  
  93.   getEntryListNodeRoot       =    TreeNodePtr( 0);
  94.   getEntryListNodeActive     =    TreeNodePtr(-2);
  95.  
  96.   getEntryPositionHead       =     0;
  97.   getEntryPositionTail       =    -1;
  98.   getEntryPositionActive     =    -2;
  99.   getEntryPositionNext       =    -3;
  100.   getEntryPositionPrevious   =    -4;
  101.   getEntryPositionParent     =    -5;
  102.  
  103.   getNrTreeNodeActive        =    TreeNodePtr(-2);
  104.  
  105.   insertListNodeRoot         =    TreeNodePtr( 0);
  106.   insertListNodeActive       =    TreeNodePtr(-2);
  107.  
  108.   insertPrevNodeHead         =    TreeNodePtr( 0);
  109.   insertPrevNodeTail         =    TreeNodePtr(-1);
  110.   insertPrevNodeActive       =    TreeNodePtr(-2);
  111.   insertPrevNodeSorted       =    TreeNodePtr(-4);
  112.  
  113.   moveOldListNodeRoot        =    TreeNodePtr( 0);
  114.   moveOldListNodeActive      =    TreeNodePtr(-2);
  115.  
  116.   moveOldTreeNodeHead        =    TreeNodePtr( 0);
  117.   moveOldTreeNodeTail        =    TreeNodePtr(-1);
  118.   moveOldTreeNodeActive      =    TreeNodePtr(-2);
  119.  
  120.   moveNewListNodeRoot        =    TreeNodePtr( 0);
  121.   moveNewListNodeActive      =    TreeNodePtr(-2);
  122.  
  123.   moveNewTreeNodeHead        =    TreeNodePtr( 0);
  124.   moveNewTreeNodeTail        =    TreeNodePtr(-1);
  125.   moveNewTreeNodeActive      =    TreeNodePtr(-2);
  126.   moveNewTreeNodeSorted      =    TreeNodePtr(-4);
  127.  
  128.   openListNodeRoot           =    TreeNodePtr( 0);
  129.   openListNodeParent         =    TreeNodePtr(-1);
  130.   openListNodeActive         =    TreeNodePtr(-2);
  131.   openTreeNodeHead           =    TreeNodePtr( 0);
  132.   openTreeNodeTail           =    TreeNodePtr(-1);
  133.   openTreeNodeActive         =    TreeNodePtr(-2);
  134.   openTreeNodeAll            =    TreeNodePtr(-3);
  135.  
  136.   removeListNodeRoot         =    TreeNodePtr( 0);
  137.   removeListNodeActive       =    TreeNodePtr(-2);
  138.   removeTreeNodeHead         =    TreeNodePtr( 0);
  139.   removeTreeNodeTail         =    TreeNodePtr(-1);
  140.   removeTreeNodeActive       =    TreeNodePtr(-2);
  141.   removeTreeNodeAll          =    TreeNodePtr(-3);
  142.  
  143.   renameTreeNodeActive       =    TreeNodePtr(-2);
  144.  
  145.   setDropMarkEntryNone       =    -1;
  146.  
  147. TYPE
  148.   SetDropMarks    = (none, above, below, onto, sorted, makeLong = $10000);
  149.  
  150.   CloseFlags      = (visible = 14, nr, makeLong=31);
  151.   CloseFlagSet    = SET OF CloseFlags;
  152.  
  153.   ExchangeFlagSet = System.LONGSET;
  154.  
  155.   FindNameFlags   = (visible = 14, sameLevel, makeLong=31);
  156.   FindNameFlagSet = SET OF FindNameFlags;
  157.  
  158.   GetEntryFlags   = FindNameFlags;
  159.   GetEntryFlagSet = FindNameFlagSet;
  160.  
  161.   GetNrFlags      = (listEmpty = 12, countList, countLevel, countAll, makeLong=31);
  162.   GetNrFlagSet    = SET OF GetNrFlags;
  163.  
  164.   InsertFlags     = (open,  list,  freeze, nosign,
  165.                      nextNode = 12, active, visible, nr, makeLong=31);
  166.   InsertFlagSet   = SET OF InsertFlags;
  167.  
  168.   OpenFlags       = CloseFlags;
  169.   OpenFlagSet     = CloseFlagSet;
  170.  
  171.   MoveFlags       = CloseFlags;
  172.   MoveFlagSet     = CloseFlagSet;
  173.  
  174.   RemoveFlags     = CloseFlags;
  175.   RemoveFlagSet   = CloseFlagSet;
  176.  
  177.   RenameFlags     = (user = 8, makeLong = 31);
  178.   RenameFlagSet   = SET OF RenameFlags;
  179.  
  180.   DoubleClick     = (tree = -3, all, off);
  181.  
  182. CONST
  183.   activeOff                  =   0;
  184.  
  185.   constructHookString        =  HookPtr(-1);
  186.  
  187.   destructHookString         =  HookPtr(-1);
  188.  
  189.   displayHookDefault         =  HookPtr(-1);
  190.  
  191.   sortHookHead               =  HookPtr( 0);
  192.   sortHookTail               =  HookPtr(-1);
  193.   sortHookLeavesTop          =  HookPtr(-2);
  194.   sortHookLeavesMixed        =  HookPtr(-3);
  195.   sortHookLeavesBottom       =  HookPtr(-4);
  196.  
  197.  
  198.   mListtreeClose                = MethodID($8002001F);
  199.   mListtreeExchange             = MethodID($80020008);
  200.   mListtreeFindName             = MethodID($8002003C);
  201.   mListtreeGetEntry             = MethodID($8002002B);
  202.   mListtreeGetNr                = MethodID($8002000E);
  203.   mListtreeInsert               = MethodID($80020011);
  204.   mListtreeMove                 = MethodID($80020009);
  205.   mListtreeOpen                 = MethodID($8002001E);
  206.   mListtreeRemove               = MethodID($80020012);
  207.   mListtreeRename               = MethodID($8002000C);
  208.   mListtreeSetDropMark          = MethodID($8002004C);
  209.   mListtreeTestPos              = MethodID($8002004B);
  210.  
  211.   aListtreeActive               = LONGCARD($80020020);
  212.   aListtreeCloseHook            = LONGCARD($80020033);
  213.   aListtreeConstructHook        = LONGCARD($80020016);
  214.   aListtreeDestructHook         = LONGCARD($80020017);
  215.   aListtreeDisplayHook          = LONGCARD($80020018);
  216.   aListtreeDoubleClick          = LONGCARD($8002000D);
  217.   aListtreeDragDropSort         = LONGCARD($80020031);
  218.   aListtreeDuplicateNodeName    = LONGCARD($8002003D);
  219.   aListtreeEmptyNodes           = LONGCARD($80020030);
  220.   aListtreeFormat               = LONGCARD($80020014);
  221.   aListtreeOpenHook             = LONGCARD($80020032);
  222.   aListtreeQuiet                = LONGCARD($8002000A);
  223.   aListtreeSortHook             = LONGCARD($80020010);
  224.   aListtreeTitle                = LONGCARD($80020015);
  225.   aListtreeTreeColumn           = LONGCARD($80020013);
  226.  
  227. TYPE
  228.   ListtreeTags = TAGS OF MuiTags
  229.     listtreeActive             = $80020020 : TreeNodePtr;
  230.     listtreeCloseHook          = $80020033 : HookPtr;
  231.     listtreeConstructHook      = $80020016 : HookPtr;
  232.     listtreeDestructHook       = $80020017 : HookPtr;
  233.     listtreeDisplayHook        = $80020018 : HookPtr;
  234.     listtreeDoubleClickColumn  = $8002000D : LONGINT;
  235.     listtreeDoubleClick        = $8002000D : DoubleClick;
  236.     listtreeDragDropSort       = $80020031 : CBOOLEAN;
  237.     listtreeDuplicateNodeName  = $8002003D : CBOOLEAN;
  238.     listtreeEmptyNodes         = $80020030 : CBOOLEAN;
  239.     listtreeFormat             = $80020014 : SysStringPtr;
  240.     listtreeOpenHook           = $80020032 : HookPtr;
  241.     listtreeQuiet              = $8002000A : CBOOLEAN;
  242.     listtreeSortHook           = $80020010 : HookPtr;
  243.     listtreeTitle              = $80020015 : SysStringPtr;
  244.     listtreeTitleMultiColumn   = $80020015 : CBOOLEAN;
  245.     listtreeTreeColumn         = $80020013 : LONGCARD;
  246.   END;
  247.  
  248.   ListtreeTagAPtr = POINTER TO ARRAY OF ListtreeTags;
  249.  
  250.   pListtreeClosePtr = POINTER TO pListtreeClose;
  251.   pListtreeClose = RECORD OF MsgRoot
  252.                      listNode,
  253.                      treeNode     : TreeNodePtr;
  254.                      flags        : CloseFlagSet;
  255.                    END; (* RECORD *)
  256.  
  257.   pListtreeExchangePtr = POINTER TO pListtreeExchange;
  258.   pListtreeExchange = RECORD OF MsgRoot
  259.                         listNode1,
  260.                         treeNode1,
  261.                         listNode2,
  262.                         treeNode2    : TreeNodePtr;
  263.                         flags        : ExchangeFlagSet;
  264.                       END; (* RECORD *)
  265.  
  266.   pListtreeFindNamePtr = POINTER TO pListtreeFindName;
  267.   pListtreeFindName = RECORD OF MsgRoot
  268.                         listNode     : TreeNodePtr;
  269.                         name         : SysStringPtr;
  270.                         flags        : FindNameFlagSet;
  271.                       END; (* RECORD *)
  272.  
  273.   pListtreeGetEntryPtr = POINTER TO pListtreeGetEntry;
  274.   pListtreeGetEntry = RECORD OF MsgRoot
  275.                         node         : TreeNodePtr;
  276.                         position     : LONGINT;
  277.                         flags        : GetEntryFlagSet;
  278.                       END; (* RECORD *)
  279.  
  280.   pListtreeGetNrPtr = POINTER TO pListtreeGetNr;
  281.   pListtreeGetNr = RECORD OF MsgRoot
  282.                      treeNode     : TreeNodePtr;
  283.                      flags        : GetNrFlagSet;
  284.                    END; (* RECORD *)
  285.  
  286.   pListtreeInsertPtr = POINTER TO pListtreeInsert;
  287.   pListtreeInsert = RECORD OF MsgRoot
  288.                       name         : SysStringPtr;
  289.                       user         : ANYPTR;
  290.                       listNode     : TreeNodePtr;
  291.                       IF KEY : InsertFlags
  292.                         OF nr THEN prevPos  : LONGINT;
  293.                         ELSE       prevNode : TreeNodePtr;
  294.                       END;
  295.                       flags        : InsertFlagSet;
  296.                     END; (* RECORD *)
  297.  
  298.   pListtreeMovePtr = POINTER TO pListtreeMove;
  299.   pListtreeMove = RECORD OF MsgRoot
  300.                     oldListNode,
  301.                     oldTreeNode,
  302.                     newListNode,
  303.                     newTreeNode  : TreeNodePtr;
  304.                     flags        : MoveFlagSet;
  305.                   END; (* RECORD *)
  306.  
  307.   pListtreeOpenPtr = POINTER TO pListtreeOpen;
  308.   pListtreeOpen = RECORD OF MsgRoot
  309.                     listNode,
  310.                     treeNode     : TreeNodePtr;
  311.                     flags        : OpenFlagSet;
  312.                   END; (* RECORD *)
  313.  
  314.   pListtreeRemovePtr = POINTER TO pListtreeRemove;
  315.   pListtreeRemove = RECORD OF MsgRoot
  316.                       listNode,
  317.                       treeNode     : TreeNodePtr;
  318.                       flags        : RemoveFlagSet;
  319.                     END; (* RECORD *)
  320.  
  321.   pListtreeRenamePtr = POINTER TO pListtreeRename;
  322.   pListtreeRename = RECORD OF MsgRoot
  323.                       treeNode     : TreeNodePtr;
  324.                       newName      : SysStringPtr;
  325.                       flags        : RenameFlagSet;
  326.                     END; (* RECORD *)
  327.  
  328.   pListtreeSetDropMarkPtr = POINTER TO pListtreeSetDropMark;
  329.   pListtreeSetDropMark = RECORD OF MsgRoot
  330.                            entry        : LONGINT;
  331.                            values       : SetDropMarks;
  332.                          END; (* RECORD *)
  333.  
  334.   pListtreeTestPosPtr = POINTER TO pListtreeTestPos;
  335.   pListtreeTestPos = RECORD OF MsgRoot
  336.                        x, y         : LONGINT;
  337.                        result       : POINTER TO TestPosResult;
  338.                      END; (* RECORD *)
  339.  
  340.   TestPosResultFlags = (none, above, below, onto, sorted, makeWord = $100);
  341.  
  342.   TestPosResultPtr = POINTER TO TestPosResult;
  343.   TestPosResult    = RECORD
  344.                        treeNode     : TreeNodePtr;
  345.                        flags        : TestPosResultFlags;
  346.                        listEntry    : LONGINT;
  347.                        listFlags    : CARDINAL;
  348.                      END; (* RECORD *)
  349.  
  350.  
  351.  
  352. PROCEDURE MakeListtreeObjectA (tags : ListtreeTagAPtr) : ListtreeObject;
  353. PROCEDURE MakeListtreeObject  (tags : LIST OF ListtreeTags) : ListtreeObject;
  354.  
  355. METHOD Close    (o : ListtreeObject; listNode,  treeNode : TreeNodePtr;           flags := CloseFlagSet    : {});
  356. METHOD Exchange (o : ListtreeObject; listNode1, treeNode1,
  357.                                      listNode2, treeNode2 : TreeNodePtr;          flags := ExchangeFlagSet : {});
  358. METHOD FindName (o : ListtreeObject; listNode : TreeNodePtr; name : SysStringPtr; flags := FindNameFlagSet : {}) : TreeNodePtr;
  359. METHOD GetEntry (o : ListtreeObject; node     : TreeNodePtr; position : LONGINT;  flags := GetEntryFlagSet : {}) : TreeNodePtr;
  360. METHOD GetNr    (o : ListtreeObject; treeNode : TreeNodePtr;                      flags := GetNrFlagSet    : {})  : LONGCARD;
  361. METHOD Insert   (o : ListtreeObject; name : SysStringPtr; user : ANYPTR;
  362.                                      listNode, prevNode : TreeNodePtr;            flags := InsertFlagSet   : {}) : TreeNodePtr;
  363. METHOD Move     (o : ListtreeObject; oldListNode, oldTreeNode,
  364.                                      newListNode, newTreeNode  : TreeNodePtr;     flags := MoveFlagSet     : {});
  365. METHOD Open     (o : ListtreeObject; listNode, treeNode : TreeNodePtr;            flags := OpenFlagSet     : {});
  366. METHOD Remove   (o : ListtreeObject; listNode, treeNode : TreeNodePtr;            flags := RemoveFlagSet   : {});
  367. METHOD Rename   (o : ListtreeObject; treeNode : TreeNodePtr; newName : SysStringPtr; flags := RenameFlagSet : {}) : TreeNodePtr;
  368. METHOD TestPos  (o : ListtreeObject; x, y : LONGINT; VAR result : TestPosResult);
  369. METHOD SetDropMark (o : ListtreeObject; entry : LONGINT; values : SetDropMarks);
  370.  
  371. GROUP
  372.   SpecialValueGrp =
  373.     closeListNodeRoot,       closeListNodeParent,
  374.     closeListNodeActive,
  375.     closeTreeNodeHead,       closeTreeNodeTail,
  376.     closeTreeNodeActive,     closeTreeNodeAll,
  377.     exchangeListNode1Root,   exchangeListNode1Active,
  378.     exchangeTreeNode1Head,   exchangeTreeNode1Tail,
  379.     exchangeTreeNode1Active, exchangeListNode2Root,
  380.     exchangeListNode2Active, exchangeTreeNode2Head,
  381.     exchangeTreeNode2Tail,   exchangeTreeNode2Active,
  382.     exchangeTreeNode2Up,     exchangeTreeNode2Down,
  383.     findNameListNodeRoot,    findNameListNodeActive,
  384.     getEntryListNodeRoot,    getEntryListNodeActive,
  385.     getEntryPositionHead,    getEntryPositionTail,
  386.     getEntryPositionActive,  getEntryPositionNext,
  387.     getEntryPositionPrevious,getEntryPositionParent,
  388.     getNrTreeNodeActive,
  389.     insertListNodeRoot,      insertListNodeActive,
  390.     insertPrevNodeHead,      insertPrevNodeTail,
  391.     insertPrevNodeActive,    insertPrevNodeSorted,
  392.     moveOldListNodeRoot,     moveOldListNodeActive,
  393.     moveOldTreeNodeHead,     moveOldTreeNodeTail,
  394.     moveOldTreeNodeActive,
  395.     moveNewListNodeRoot,     moveNewListNodeActive,
  396.     moveNewTreeNodeHead,     moveNewTreeNodeTail,
  397.     moveNewTreeNodeActive,   moveNewTreeNodeSorted,
  398.     openListNodeRoot,        openListNodeParent,
  399.     openListNodeActive,
  400.     openTreeNodeHead,        openTreeNodeTail,
  401.     openTreeNodeActive,      openTreeNodeAll,
  402.     removeListNodeRoot,      removeListNodeActive,
  403.     removeTreeNodeHead,      removeTreeNodeTail,
  404.     removeTreeNodeActive,    removeTreeNodeAll,
  405.     renameTreeNodeActive,
  406.     setDropMarkEntryNone,
  407.     SetDropMarks, DoubleClick,
  408.     activeOff,          constructHookString,
  409.     destructHookString, displayHookDefault,
  410.     sortHookHead,       sortHookTail,
  411.     sortHookLeavesTop,  sortHookLeavesMixed,
  412.     sortHookLeavesBottom;
  413.  
  414.   FlagGrp =
  415.     CloseFlags,      CloseFlagSet,
  416.     ExchangeFlagSet,
  417.     FindNameFlags,   FindNameFlagSet,
  418.     GetEntryFlags,   GetEntryFlagSet,
  419.     GetNrFlags,      GetNrFlagSet,
  420.     InsertFlags,     InsertFlagSet,
  421.     OpenFlags,       OpenFlagSet,
  422.     MoveFlags,       MoveFlagSet,
  423.     RemoveFlags,     RemoveFlagSet,
  424.     RenameFlags,     RenameFlagSet;
  425.  
  426.   MethodGrp =
  427.     mListtreeClose,         mListtreeExchange,
  428.     mListtreeFindName,      mListtreeGetEntry,
  429.     mListtreeGetNr,         mListtreeInsert,
  430.     mListtreeMove,          mListtreeOpen,
  431.     mListtreeRemove,        mListtreeRename,
  432.     mListtreeSetDropMark,   mListtreeTestPos;
  433.  
  434.   TagGrp =
  435.     aListtreeActive,        aListtreeCloseHook,
  436.     aListtreeConstructHook, aListtreeDestructHook,
  437.     aListtreeDisplayHook,   aListtreeDoubleClick,
  438.     aListtreeDragDropSort,  aListtreeDuplicateNodeName,
  439.     aListtreeEmptyNodes,    aListtreeFormat,
  440.     aListtreeOpenHook,      aListtreeQuiet,
  441.     aListtreeSortHook,      aListtreeTitle,
  442.     aListtreeTreeColumn;
  443.  
  444.   BasicGrp =
  445.     MakeListtreeObjectA, MakeListtreeObject,
  446.     ListtreeTagAPtr, ListtreeTags,
  447.     ListtreeObject,  TreeNodePtr;
  448.  
  449.   All = TagGrp, FlagGrp, BasicGrp, SpecialValueGrp;
  450.  
  451. END MCCListtree.
  452.  
  453.